包名 结绳.JVM

@全局类
@导入Java("java.util.concurrent.*")
类 线程池
	@code
	public static ExecutorService cachedThreadPool;
	public static ExecutorService fixedThreadPool;
	@end

	@静态
	变量 线程池大小 : 整数

	@静态
	@嵌入式代码
	方法 提交到缓存线程池运行()
		@code
		if (#<线程池>.cachedThreadPool == null || #<线程池>.cachedThreadPool.isShutdown()) {
			#<线程池>.cachedThreadPool = java.util.concurrent.Executors.newCachedThreadPool();
		}
		#<线程池>.cachedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
		@end
	结束 方法

	@静态
	@嵌入式代码
	方法 结束提交到缓存线程池()
		@code
			}
		});
		@end
	结束 方法

	@静态
	方法 停止缓存线程池所有任务()
		@code
		if (cachedThreadPool != null) {
			cachedThreadPool.shutdown();
		}
		@end
	结束 方法

	@静态
	方法 等待缓存线程池执行完毕()
		@code
		if (cachedThreadPool != null) {
			#停止缓存线程池所有任务();
			try {
				cachedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
			} catch (Exception e) {
			}
		}
		@end
	结束 方法

	@静态
	方法 置固定线程池大小(大小 为 整数)
		@code
		#线程池大小 = ((#大小 <= 0) ? (Runtime.getRuntime().availableProcessors() * 2) : #大小);
		#<线程池>.fixedThreadPool = Executors.newFixedThreadPool(#线程池大小);
		@end
	结束 方法

	@静态
	@嵌入式代码
	方法 提交到固定线程池运行()
		@code
		if (#<线程池>.fixedThreadPool == null || #<线程池>.fixedThreadPool.isShutdown()) {
			#<线程池.置固定线程池大小>(#<线程池.线程池大小>);
		}
		#<线程池>.fixedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
		@end
	结束 方法

	@静态
	@嵌入式代码
	方法 结束提交到固定线程池()
		@code
			}
		});
		@end
	结束 方法

	@静态
	方法 停止固定线程池所有任务()
		@code
		if (fixedThreadPool != null) {
			fixedThreadPool.shutdown();
		}
		@end
	结束 方法

	@静态
	方法 等待固定线程池执行完毕()
		@code
		if (fixedThreadPool != null) {
			#停止固定线程池所有任务();
			try {
				fixedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
			} catch (Exception e) {
			}
		}
		@end
	结束 方法
结束 类

@全局类
类 线程锁
	@静态
	@嵌入式代码
	方法 获取线程同步锁(锁对象 : 对象)
		@code
		synchronized (#锁对象) {
		@end
	结束 方法

	@静态
	@嵌入式代码
	方法 释放线程同步锁()
		@code
		}
		@end
	结束 方法
结束 类

@指代类("java.util.concurrent.locks.ReentrantReadWriteLock")
类 读写锁
	方法 获取读锁()
		code #this.readLock().lock();
	结束 方法

	方法 释放读锁()
		code #this.readLock().unlock();
	结束 方法

	方法 获取写锁()
		code #this.writeLock().lock();
	结束 方法

	方法 释放写锁()
		code #this.writeLock().unlock();
	结束 方法
结束 类

@指代类("java.util.Vector")
类 并发集合模板类<模板类型1> : 可枚举类

	@运算符重载
	方法 =(成员 : 模板类型1[])
		@code
		java.util.Vector<#<@模板类型1>> list = new java.util.Vector<>(#成员.length);
		for(#<@模板类型1> el : #成员) {
			list.add(el);
		}
		return list;
		@end
	结束 方法

	@运算符重载
	方法 [](索引 : 整数) : 模板类型1
		返回 取成员(索引)
	结束 方法

	@运算符重载
	方法 []=(索引 : 整数,值 : 模板类型1)
		置成员(索引, 值)
	结束 方法

	@运算符重载
	方法 ?(值 : 模板类型1) : 逻辑型
		返回 是否存在(值)
	结束 方法

	方法 是否为空() : 逻辑型
		code return #this.isEmpty();
	结束 方法

	方法 添加成员(成员 : 模板类型1)
		code #this.add(#成员);
	结束 方法

	方法 插入成员(索引 : 整数,成员 : 模板类型1)
		code #this.add(#索引,#成员);
	结束 方法

	方法 置成员(索引 : 整数,成员 : 模板类型1)
		code #this.set(#索引,#成员);
	结束 方法

	方法 取成员(索引 : 整数) : 模板类型1
		code return #this.get(#索引);
	结束 方法

	方法 是否存在(成员 : 模板类型1) : 逻辑型
		code return #this.contains(#成员);
	结束 方法

	方法 寻找成员(成员 : 模板类型1) : 整数
		code return #this.indexOf(#成员);
	结束 方法

	//清空集合
	方法 清空()
		code #this.clear();
	结束 方法

	//删除指定索引处成员
	方法 删除成员(索引 : 整数)
		code #this.remove(#索引);
	结束 方法

	//删除指定成员对象
	方法 删除成员2(成员 : 模板类型1)
		code #this.remove(#成员);
	结束 方法

	/*
	将集合转为数组
	*/
	方法 到数组() : 模板类型1[]
		code return #this.toArray(new #<@模板类型1>[0]);
	结束 方法

	方法 打乱集合()
		@code
		for (int i = 0,max = #this.size() - 1;i < max;i++) {
			if (System.nanoTime() % 2 == 0) {
				#<@模板类型1> tmp = #this.get(i);
				#this.set(i, #this.get(i + 1));
				#this.set(i + 1, tmp);
			}
		}
		@end
	结束 方法

	属性读 长度() : 整数
		code return #this.size();
	结束 属性

	/*
	获取枚举器，可用于迭代循环
	*/
	属性读 枚举器() : 枚举器
		code return #this.iterator();
	结束 属性
结束 类

类 并发集合 : 并发集合模板类<对象>
结束 类

类 并发整数集合 : 并发集合模板类<整数类>
结束 类

类 并发文本集合 : 并发集合模板类<文本>
结束 类

@指代类("java.util.concurrent.ConcurrentHashMap")
类 并发哈希表模板类<模板类型1,模板类型2> : 可枚举条目类
	@运算符重载
	方法 [](键 : 模板类型1) : 模板类型2
		返回 取项目(键)
	结束 方法

	@运算符重载
	方法 []=(键 : 模板类型1, 值 : 模板类型2)
		添加项目(键, 值)
	结束 方法

	@运算符重载
	方法 ?(键 : 模板类型1) : 逻辑型
		返回 是否存在(键)
	结束 方法

	方法 添加项目(键 : 模板类型1,值 : 模板类型2)
		code #this.put(#键, #值);
	结束 方法

	方法 删除项目(键 : 模板类型1)
		code #this.remove(#键);
	结束 方法

	方法 取项目(键 : 模板类型1) : 模板类型2
		code return #this.get(#键);
	结束 方法

	方法 是否存在(键 : 模板类型1) : 逻辑型
		code return #this.containsKey(#键);
	结束 方法

	方法 清空()
		code #this.clear();
	结束 方法

	属性读 长度() : 整数
		code return #this.size();
	结束 属性
结束 类

类 并发哈希表 : 并发哈希表模板类<对象, 对象>
结束 类